//#include <stdio.h>
//#include <stdlib.h>
//
//#define HASH_SIZE 15000001
//
//typedef struct 
//{
//    long long key;
//    int count;
//} HashNode;
//
//HashNode* hashTable;
//
//void insert(long long key) 
//{
//    long long idx = (key % HASH_SIZE + HASH_SIZE) % HASH_SIZE;
//    while (hashTable[idx].count != 0 && hashTable[idx].key != key)
//    {
//        idx = (idx + 1) % HASH_SIZE;
//    }
//    if (hashTable[idx].count == 0) 
//    {
//        hashTable[idx].key = key;
//        hashTable[idx].count = 1;
//    }
//    else 
//    {
//        hashTable[idx].count++;
//    }
//}
//
//int find(long long key) 
//{
//    long long idx = (key % HASH_SIZE + HASH_SIZE) % HASH_SIZE;
//    while (hashTable[idx].count != 0) 
//    {
//        if (hashTable[idx].key == key)
//        {
//            return hashTable[idx].count;
//        }
//        idx = (idx + 1) % HASH_SIZE;
//    }
//    return 0;
//}
//
//int main() 
//{
//    int n;
//    scanf_s("%d", &n);
//    long long* col1 = (long long*)malloc(n * sizeof(long long));
//    long long* col2 = (long long*)malloc(n * sizeof(long long));
//    long long* col3 = (long long*)malloc(n * sizeof(long long));
//    long long* col4 = (long long*)malloc(n * sizeof(long long));
//
//    for (int i = 0; i < n; i++)
//    {
//        scanf_s("%lld %lld %lld %lld", &col1[i], &col2[i], &col3[i], &col4[i]);
//    }
//
//    hashTable = (HashNode*)calloc(HASH_SIZE, sizeof(HashNode));
//
//    for (int i = 0; i < n; i++) 
//    {
//        for (int j = 0; j < n; j++) 
//        {
//            long long sum = col1[i] + col2[j];
//            insert(sum);
//        }
//    }
//
//    long long ans = 0;
//    for (int i = 0; i < n; i++) 
//    {
//        for (int j = 0; j < n; j++) 
//        {
//            long long sum = col3[i] + col4[j];
//            ans += find(-sum);
//        }
//    }
//
//    printf("%lld\n", ans);
//
//    free(col1);
//    free(col2);
//    free(col3);
//    free(col4);
//    free(hashTable);
//
//    return 0;
//}
#include <stdio.h>
#include <stdlib.h>

#define MAXN 100000
#define MAXL ((MAXN)*((MAXN)+1)/2)

int a[MAXN];
int b[MAXL];

typedef struct
{
    int* h;
    int sz;
} MinHeap;

static void heap_push(MinHeap* hp, int v) 
{
    int i = hp->sz++, p;
    hp->h[i] = v;
    while (i) 
    {
        p = (i - 1) >> 1;
        if (hp->h[p] <= hp->h[i]) break;
        int t = hp->h[p]; hp->h[p] = hp->h[i]; hp->h[i] = t;
        i = p;
    }
}

static void heap_pop(MinHeap* hp)
{
    int i = 0, l, r, smallest, n = --hp->sz;
    if (!n) return;
    hp->h[0] = hp->h[n];
    while (1)
    {
        l = (i << 1) + 1;
        r = l + 1;
        smallest = i;
        if (l < n && hp->h[l] < hp->h[smallest]) smallest = l;
        if (r < n && hp->h[r] < hp->h[smallest]) smallest = r;
        if (smallest == i) break;
        int t = hp->h[i]; hp->h[i] = hp->h[smallest]; hp->h[smallest] = t;
        i = smallest;
    }
}

static int cmp_desc(const void* x, const void* y)
{
    return *(int*)y - *(int*)x;
}

int main()
{
    int T;
    scanf_s("%d", &T);
    while (T--) 
    {
        int n, k;
        long long m;
        scanf_s("%d %d %lld", &n, &k, &m);

        for (int i = 0; i < n; i++) 

            scanf_s("%d", &a[i]);

        static int heap_buf[MAXN];

        MinHeap hp = { heap_buf, 0 };

        int b_cnt = 0;

        for (int len = k; len <= n; len++) 
        {
            hp.sz = 0;
            for (int i = 0; i < len; i++) 
            {
                if (hp.sz < k) 
                {
                    heap_push(&hp, a[i]);
                }
                else if (a[i] > hp.h[0])
                {
                    heap_pop(&hp);
                    heap_push(&hp, a[i]);
                }
            }
            b[b_cnt++] = hp.h[0];

            for (int i = len; i < n; i++) 
            {
                hp.sz = 0;
                for (int j = i - len + 1; j <= i; j++) 
                {
                    if (hp.sz < k) 
                    {
                        heap_push(&hp, a[j]);
                    }
                    else if (a[j] > hp.h[0]) 
                    {
                        heap_pop(&hp);
                        heap_push(&hp, a[j]);
                    }
                }
                b[b_cnt++] = hp.h[0];
            }
        }

        qsort(b, b_cnt, sizeof(int), cmp_desc);

        printf("%d\n", b[m - 1]);
    }
    return 0;
}